In [1]:
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import datetime
import seaborn as sns
import warnings
warnings.filterwarnings('ignore')
import re
from sklearn.model_selection import train_test_split
from collections import Counter
import time
import plotly.express as px
In [2]:
injuries_df = pd.read_csv("C:\\Users\\DELL8\\OneDrive\\Pictures\\injuries.csv")

Dataset Description¶

This dataset provides information about athlete injuries and the corresponding dates of injury occurrences.

Columns Overview¶

  1. athlete_id (integer):

    • A unique identifier for each athlete.
    • Range: 1 to 30.

  2. date (string):

    • The date when the injury was recorded, formatted as YYYY-MM-DD.
    • Example: 2016-05-11.

Dataset Summary¶

  • Total Records: 137
  • Unique Athletes: 30
  • Unique Dates: 126
  • Most Frequent Injury Date: 2016-05-16 (4 occurrences)

Potential Use Cases¶

  • Analysis of injury patterns over time for athletes.
  • Identifying high-risk periods for injuries.
  • Exploring the frequency of injuries for individual athletes.
In [3]:
injuries_df
Out[3]:
athlete_id date
0 1 2016-05-11
1 1 2016-05-16
2 1 2016-07-28
3 1 2016-11-11
4 1 2016-12-16
... ... ...
132 29 2018-03-30
133 29 2018-04-30
134 30 2016-05-28
135 30 2017-07-13
136 30 2017-09-20

137 rows × 2 columns

In [4]:
injuries_df.describe()
Out[4]:
athlete_id
count 137.000000
mean 15.605839
std 9.653068
min 1.000000
25% 6.000000
50% 18.000000
75% 24.000000
max 30.000000
In [5]:
injuries_df.info
Out[5]:
<bound method DataFrame.info of      athlete_id        date
0             1  2016-05-11
1             1  2016-05-16
2             1  2016-07-28
3             1  2016-11-11
4             1  2016-12-16
..          ...         ...
132          29  2018-03-30
133          29  2018-04-30
134          30  2016-05-28
135          30  2017-07-13
136          30  2017-09-20

[137 rows x 2 columns]>
In [6]:
injuries_df.shape
Out[6]:
(137, 2)
In [7]:
# Convert the 'date' column to datetime format
injuries_df['date'] = pd.to_datetime(injuries_df['date'], errors='coerce')
In [8]:
# Check for duplicate rows
duplicates = injuries_df.duplicated().sum()
duplicates
Out[8]:
np.int64(0)
In [9]:
# Remove duplicate rows if any
data_cleaned =injuries_df.drop_duplicates()
In [10]:
data_cleaned.head()
Out[10]:
athlete_id date
0 1 2016-05-11
1 1 2016-05-16
2 1 2016-07-28
3 1 2016-11-11
4 1 2016-12-16
In [11]:
injury_counts = data_cleaned.groupby("athlete_id").count().reset_index()
In [12]:
injury_counts = injury_counts.rename(columns={'date': 'total_injuries'})
In [13]:
injury_counts.sort_values(by="total_injuries", ascending=False, inplace=True)
In [14]:
injury_counts.head()
Out[14]:
athlete_id total_injuries
0 1 12
23 25 12
20 22 10
2 3 9
1 2 7

Top 5 Athletes by Total Injuries¶

In [15]:
plt.figure(figsize=(8, 4))
sns.barplot(
    x='athlete_id', 
    y='total_injuries', 
    data=injury_counts.head(5), # Top 10 athletes
    palette="viridis"
)
plt.title("Top 5 Athletes by Total Injuries", fontsize=16)
plt.xlabel("Athlete ID", fontsize=12)
plt.ylabel("Total Injuries", fontsize=12)
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()
No description has been provided for this image

Observation: The bar plot highlights the top 5 athletes with the highest total number of injuries. The x-axis represents athlete IDs, while the y-axis shows the total number of injuries for each athlete. The bars are color-coded using the "viridis" palette, and the athlete IDs are displayed on the x-axis with a 45-degree rotation for better readability.

Conclusion: The plot provides a clear view of which athletes are more prone to injuries. This information can be useful for further investigation into the causes of these injuries, whether they are related to the athlete's playing style, training routines, or other factors. Identifying athletes with frequent injuries might also help in implementing tailored recovery programs or preventive measures.

Yearly Trend of Injuries¶

In [16]:
data_cleaned['year_month'] = data_cleaned['date'].dt.to_period('M')

monthly_injuries = data_cleaned.groupby('year_month').size().reset_index(name='injuries')

monthly_injuries['year_month'] = monthly_injuries['year_month'].astype(str)

# Plot the Monthly Trend
plt.figure(figsize=(12, 6))
plt.plot(monthly_injuries['year_month'], monthly_injuries['injuries'], marker='o', linestyle='-', color='green')

# Formatting
plt.title("Monthly Trend of Injuries", fontsize=16)
plt.xlabel("Year-Month", fontsize=12)
plt.ylabel("Number of Injuries", fontsize=12)
plt.xticks(rotation=45)  # Rotate x-axis labels for readability
plt.grid(True)
plt.tight_layout()

# Show the plot
plt.show()
No description has been provided for this image

Observation: The line plot shows the trend of injuries over the years. The x-axis represents the years, while the y-axis displays the number of injuries recorded each year. Data points are marked with circles, and the line provides a clear visual of injury fluctuations across time. The grid helps in visually tracking the changes.

Conclusion: This plot reveals how the number of injuries has varied over the years. Identifying upward or downward trends in injuries over time can guide further analysis into the causes or preventive measures. A consistent increase in injuries might suggest areas to investigate, such as training practices, player fatigue, or other influencing factors. Conversely, a decrease could indicate successful injury prevention strategies or changes in team management.

Dataset 2¶

In [17]:
player_stats_df=pd.read_csv( "C:\\Users\\DELL8\\OneDrive\\Desktop\\player_stats.csv")

Dataset Description: Player Match Statistics¶

This dataset contains detailed player performance information across various matches. It can be used to analyze player involvement, substitutions, disciplinary actions, and whether the player was part of the home team.

Column Descriptions¶

  1. player_id (object):

    • Unique identifier for each player.
    • Total unique players: 4,992.

  2. match_id (integer):

    • Unique identifier for each match.
    • Range: 1 to 66,601.

  3. is_in_starting_11 (integer):

    • Indicates whether the player was part of the starting lineup (1 for yes, 0 for no).
    • Average participation as a starter: 71%.

  4. substitution_on (object):

    • The minute when the player was substituted onto the field, or "Null" if they were never substituted on.

  5. substitution_off (object):

    • The minute when the player was substituted off the field, or "Null" if they were never substituted off.

  6. yellow_card (object):

    • Indicates whether the player received a yellow card.
    • Values: "True" (received), "Null" (not received).

  7. red_card (object):

    • Indicates whether the player received a red card.
    • Values: "True" (received), "Null" (not received).

  8. is_home_side (integer):

    • Indicates if the player was part of the home team (1 for yes, 0 for no).

Dataset Summary¶

  • Total Records: 356,465
  • Unique Players: 4,992
  • Unique Matches: 66,601
  • Most Frequent Substitution On/Off Minute: "Null" (no substitution)
  • Yellow Cards: Most players did not receive yellow cards (321,323 records as "Null").
  • Red Cards: Very few records indicate red card occurrences.
  • Home vs Away Matches: Balanced, with 50% being home matches.

Potential Use Cases¶

  • Analyzing player participation trends.
  • Studying substitution patterns.
  • Assessing player discipline through yellow and red cards.
  • Evaluating home and away team performances.
In [18]:
player_stats_df
Out[18]:
player_id match_id is_in_starting_11 substitution_on substitution_off yellow_card red_card is_home_side
0 p1 4 1 Null Null Null Null 0
1 p1 12 1 Null Null Null Null 1
2 p1 24 1 Null Null Null Null 1
3 p1 41 1 Null Null Null Null 0
4 p1 46 1 Null 83' True Null 0
... ... ... ... ... ... ... ... ...
356460 p999 7462 0 70' Null Null Null 1
356461 p999 7493 0 86' Null True Null 1
356462 p999 7549 0 Null Null Null Null 1
356463 p999 7577 0 Null Null Null Null 0
356464 p999 7610 0 90 +1' Null Null Null 0

356465 rows × 8 columns

In [19]:
player_stats_df.shape
Out[19]:
(356465, 8)
In [20]:
player_stats_df.head()
Out[20]:
player_id match_id is_in_starting_11 substitution_on substitution_off yellow_card red_card is_home_side
0 p1 4 1 Null Null Null Null 0
1 p1 12 1 Null Null Null Null 1
2 p1 24 1 Null Null Null Null 1
3 p1 41 1 Null Null Null Null 0
4 p1 46 1 Null 83' True Null 0
In [21]:
player_stats_df.isna().sum()
Out[21]:
player_id            0
match_id             0
is_in_starting_11    0
substitution_on      0
substitution_off     0
yellow_card          0
red_card             0
is_home_side         0
dtype: int64
In [22]:
player_stats_df.describe()
Out[22]:
match_id is_in_starting_11 is_home_side
count 356465.000000 356465.000000 356465.000000
mean 13094.649615 0.710202 0.500086
std 17047.732712 0.453669 0.500001
min 1.000000 0.000000 0.000000
25% 3531.000000 0.000000 0.000000
50% 6616.000000 1.000000 1.000000
75% 12221.000000 1.000000 1.000000
max 66601.000000 1.000000 1.000000

Data cleaning¶

In [23]:
player_stats_df.replace("Null", np.nan, inplace=True)
In [24]:
player_stats_df['yellow_card'] = player_stats_df['yellow_card'].notna()
player_stats_df['red_card'] = player_stats_df['red_card'].notna()
Function to Extract Minutes from Substitution Columns¶
In [25]:
def extract_minutes(value):
    if pd.isna(value):
        return np.nan
    match = re.match(r"(\d+)", value)  
    return float(match.group(1)) if match else np.nan
In [26]:
player_stats_df['substitution_on'] = player_stats_df['substitution_on'].apply(extract_minutes)
player_stats_df['substitution_off'] =player_stats_df['substitution_off'].apply(extract_minutes)
In [27]:
player_stats_df =player_stats_df.drop_duplicates()
In [28]:
player_stats_df['player_id'] = player_stats_df['player_id'].astype('category')
In [29]:
player_stats_df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 356465 entries, 0 to 356464
Data columns (total 8 columns):
 #   Column             Non-Null Count   Dtype   
---  ------             --------------   -----   
 0   player_id          356465 non-null  category
 1   match_id           356465 non-null  int64   
 2   is_in_starting_11  356465 non-null  int64   
 3   substitution_on    52852 non-null   float64 
 4   substitution_off   52887 non-null   float64 
 5   yellow_card        356465 non-null  bool    
 6   red_card           356465 non-null  bool    
 7   is_home_side       356465 non-null  int64   
dtypes: bool(2), category(1), float64(2), int64(3)
memory usage: 15.1 MB
In [30]:
player_stats_df['substitution_on'].fillna(player_stats_df['substitution_on'].mean(), inplace=True)


player_stats_df['substitution_off'].fillna(player_stats_df['substitution_off'].median(), inplace=True)
In [31]:
player_stats_df
Out[31]:
player_id match_id is_in_starting_11 substitution_on substitution_off yellow_card red_card is_home_side
0 p1 4 1 69.074983 72.0 False False 0
1 p1 12 1 69.074983 72.0 False False 1
2 p1 24 1 69.074983 72.0 False False 1
3 p1 41 1 69.074983 72.0 False False 0
4 p1 46 1 69.074983 83.0 True False 0
... ... ... ... ... ... ... ... ...
356460 p999 7462 0 70.000000 72.0 False False 1
356461 p999 7493 0 86.000000 72.0 True False 1
356462 p999 7549 0 69.074983 72.0 False False 1
356463 p999 7577 0 69.074983 72.0 False False 0
356464 p999 7610 0 90.000000 72.0 False False 0

356465 rows × 8 columns

In [32]:
player_stats_df.duplicated().sum()
Out[32]:
np.int64(0)

Correlation Heatmap¶

In [33]:
# Select numeric columns
numeric_df = player_stats_df.select_dtypes(include=['number'])

plt.figure(figsize=(10, 8))
sns.heatmap(numeric_df.corr(), annot=True, cmap='coolwarm', fmt=".2f")
plt.title("Correlation Heatmap")
plt.show()
No description has been provided for this image

Observation: The heatmap visualizes the correlation between numeric variables in the dataset, displaying values that indicate how strongly variables are related to each other. The color intensity represents the strength of the correlation, with darker colors indicating stronger correlations. The numbers within the cells show the actual correlation coefficients.

Conclusion: This correlation heatmap is a useful tool for identifying relationships between numeric variables, which could inform feature selection for machine learning models. Strong correlations between certain features may suggest redundancy, while weaker correlations could indicate more independent variables. Understanding these relationships helps in refining the model and preventing issues like multicollinearity, ensuring better predictive performance.

Encoding Categorical Data¶

In [34]:
def encode_categorical(player_stats_df):

    for col in player_stats_df.select_dtypes(include=['object', 'category']):
        player_stats_df[col] = player_stats_df[col].astype('category').cat.codes
    return player_stats_df

player_stats_df=pd.read_csv( "C:\\Users\\DELL8\\OneDrive\\Desktop\\player_stats.csv")

# Encode categorical columns
encoded_df = encode_categorical(player_stats_df)

# Display the encoded DataFrame
print("Encoded DataFrame:")
encoded_df.head()

Encoded DataFrame:
Out[34]:
player_id match_id is_in_starting_11 substitution_on substitution_off yellow_card red_card is_home_side
0 0 4 1 109 109 0 0 0
1 0 12 1 109 109 0 0 1
2 0 24 1 109 109 0 0 1
3 0 41 1 109 109 0 0 0
4 0 46 1 109 88 1 0 0

Observation: The function encode_categorical() converts categorical columns in the dataset into numeric codes, making them ready for machine learning models that require numerical inputs. After applying this function, the categorical values in columns like player names, positions, or other non-numeric features are now represented by integer codes.

Conclusion: Encoding categorical variables is a crucial preprocessing step before using the data in machine learning models. By converting categorical data into numerical form, the dataset becomes suitable for algorithms that can’t process non-numeric data directly. This step helps ensure that the dataset is ready for model training and analysis, enabling more accurate predictions and insights.

Distribution of Starting Players (is_in_starting_11)¶

In [35]:
plt.figure(figsize=(10, 6))
sns.barplot(x=player_stats_df['is_in_starting_11'].value_counts().index,  
            y=player_stats_df['is_in_starting_11'].value_counts().values, 
            palette='viridis')

plt.title(" Count of Players in Starting 11 vs. Not Starting", fontsize=14)
plt.xlabel("Starting Status (0 = No, 1 = Yes)", fontsize=12)
plt.ylabel("Number of Players", fontsize=12)
plt.xticks([0, 1], labels=["Not in Starting 11", "In Starting 11"])  

plt.grid(axis='y', linestyle='--', alpha=0.7)
plt.show()
No description has been provided for this image

Observation: The count plot visualizes the distribution of players in the starting lineup, with two categories: players who are in the starting 11 (represented by 1) and those who are not (represented by 0). The chart shows the frequency of each category, indicating how many players are typically in the starting lineup versus those who are not.

Conclusion: This plot highlights the overall participation rate of players in the starting 11. Understanding this distribution can help identify player rotation patterns or strategies used by coaches. Further analysis could assess how this affects player performance or injury rates, particularly if there are correlations between starting lineups and the frequency of injuries.

Percentage of Home vs. Away Matche¶

In [36]:
plt.figure(figsize=(8, 6))
home_away_counts = player_stats_df['is_home_side'].value_counts()
labels = ['Home', 'Away']
plt.pie(home_away_counts, labels=labels, autopct='%1.1f%%', startangle=90, colors=['lightblue', 'pink'])
plt.title("Percentage of Home vs. Away Matches")
plt.show()
No description has been provided for this image

Observation: The pie chart illustrates the proportion of home versus away matches in the dataset. The chart shows the percentage of games played at home compared to those played away, with clear visual representation of how these match locations are distributed.

Conclusion: The chart provides insight into the distribution of matches between home and away games, which could be useful for analyzing factors like home-field advantage or player performance in different environments. Further analysis could explore whether these match types correlate with injury rates, player performance, or other factors.

. Player Participation in Starting Lineups¶
In [37]:
plt.figure(figsize=(12, 6))
player_stats_df.groupby('player_id')['is_in_starting_11'].sum().nlargest(10).plot(kind='bar', color='skyblue')
plt.title('Top 10 Players with Most Starts')
plt.xlabel('Player ID')
plt.ylabel('Number of Starts')
plt.show()
No description has been provided for this image

Dataset 3¶

In [38]:
performance_df = pd.read_csv("C:\\Users\\DELL8\\Downloads\\player_performance.csv")

Dataset Description: Player Performance Data¶

Overview¶

This dataset contains 4,992 records, each representing the performance statistics of a unique football player. It focuses on key performance indicators such as goals, assists, pass accuracy, tackles, and minutes played.

Columns & Explanation¶

Column Name Data Type Description
player_id Object Unique identifier for each player.
goals Integer Total goals scored by the player. (Range: 0 to 4)
assists Integer Total assists made by the player. (Range: 0 to 4)
pass_accuracy Float Average pass accuracy percentage. (Range: 60% to 100%)
tackles Integer Number of successful tackles. (Range: 0 to 9)
minutes_played Integer Total minutes played by the player. (Range: 20 to 89)

Key Observations¶

  1. Player Performance Metrics:

    • The average player scores 2 goals and makes 2 assists per recorded match.
    • Players have a pass accuracy of ~80% on average.
    • The most aggressive tacklers can make up to 9 tackles per match.

  2. Playing Time Insights:

    • Players typically play around 54 minutes per match.
    • The minimum recorded playing time is 20 minutes, while the maximum is 89 minutes.

  3. Skill & Efficiency Trends:

    • Players with higher pass accuracy (above 90%) are likely key playmakers.
    • Players who score 4 goals in a match are exceptional finishers.
In [39]:
performance_df.head()
Out[39]:
player_id goals assists pass_accuracy tackles minutes_played
0 p1 0 2 82.32 3 23
1 p100059 1 2 78.03 5 83
2 p100180 2 2 95.71 1 89
3 p10039 3 4 83.76 3 80
4 p100412 1 4 73.92 3 52
In [40]:
performance_df.isna().sum()
Out[40]:
player_id         0
goals             0
assists           0
pass_accuracy     0
tackles           0
minutes_played    0
dtype: int64
In [41]:
performance_df.describe()
Out[41]:
goals assists pass_accuracy tackles minutes_played
count 4992.000000 4992.000000 4992.000000 4992.000000 4992.000000
mean 2.016627 2.005809 79.997019 4.511218 54.386018
std 1.408793 1.409732 11.500752 2.845285 20.255249
min 0.000000 0.000000 60.000000 0.000000 20.000000
25% 1.000000 1.000000 70.047500 2.000000 37.000000
50% 2.000000 2.000000 80.190000 5.000000 54.000000
75% 3.000000 3.000000 89.790000 7.000000 72.000000
max 4.000000 4.000000 100.000000 9.000000 89.000000
In [42]:
performance_df.shape
Out[42]:
(4992, 6)
In [43]:
duplicates =performance_df.duplicated().sum()
duplicates
Out[43]:
np.int64(0)
In [44]:
performance_df.head()
Out[44]:
player_id goals assists pass_accuracy tackles minutes_played
0 p1 0 2 82.32 3 23
1 p100059 1 2 78.03 5 83
2 p100180 2 2 95.71 1 89
3 p10039 3 4 83.76 3 80
4 p100412 1 4 73.92 3 52
In [45]:
plt.figure(figsize=(8, 5))
sns.heatmap(performance_df[["goals", "assists", "pass_accuracy", "tackles", "minutes_played"]].corr(), annot=True, cmap="coolwarm", fmt='.2f')
plt.title("Correlation Heatmap of Player Performance Metrics")
plt.show()
No description has been provided for this image

Observations:¶

The correlation between pass accuracy and assists suggests that players who are more precise in their passing tend to create more goal-scoring opportunities. A strong positive correlation between goals and assists indicates that attacking players who create chances often score as well. A negative correlation between tackles and pass accuracy could mean that defensive players focus more on breaking up plays than making accurate passes. Additionally, if minutes played strongly correlate with other stats like goals or tackles, it may suggest that higher performance numbers are partly due to more playing time rather than superior skill alone.

Conclusion:¶

The correlation heatmap provides valuable insights into how different performance metrics relate to each other in a player's game. By analyzing these correlations, we can determine which attributes tend to improve together and which may have trade-offs. Understanding these relationships helps in identifying key factors that contribute to a player’s overall effectiveness on the field.

In [46]:
import plotly.express as px

fig = px.scatter(performance_df, x="pass_accuracy", y=[1] * len(performance_df), 
                 text=performance_df["player_id"],  # Show Player ID
                 title="Player Pass Accuracy Distribution",
                 labels={"pass_accuracy": "Pass Accuracy (%)"},
                 color="pass_accuracy", size_max=10)

fig.update_traces(textposition="top center")  # Position text above points
fig.update_layout(yaxis=dict(visible=False))  # Hide y-axis

fig.show()
In [89]:
performance_df["minutes_played_bins"] = pd.cut(performance_df["minutes_played"], 
                                               bins=range(0, 110, 10), 
                                               labels=[f"{i}-{i+10}" for i in range(0, 100, 10)])

fig = px.scatter(performance_df, x="minutes_played_bins", y="tackles", 
                 text=performance_df["player_id"],  # Show Player ID
                 title="Distribution of Tackles by Minutes Played",
                 labels={"minutes_played_bins": "Minutes Played (Binned)", "tackles": "Tackles"},
                 color="minutes_played_bins", size_max=10)

fig.update_traces(textposition="top center")

fig.show()

Merging Player Injury Data and player_stats¶

In [48]:
injuries_df.rename(columns={'athlete_id': 'player_id'}, inplace=True)


player_stats_df['player_id'] = player_stats_df['player_id'].astype(str)
injuries_df['player_id'] = injuries_df['player_id'].astype(str)
# Merge datasets
combined_data = pd.merge(player_stats_df, injuries_df, how='left', on='player_id')
In [49]:
combined_data.head()
Out[49]:
player_id match_id is_in_starting_11 substitution_on substitution_off yellow_card red_card is_home_side date
0 0 4 1 109 109 0 0 0 NaT
1 0 12 1 109 109 0 0 1 NaT
2 0 24 1 109 109 0 0 1 NaT
3 0 41 1 109 109 0 0 0 NaT
4 0 46 1 109 88 1 0 0 NaT

Injuries Over Time¶

In [50]:
import matplotlib.pyplot as plt
import pandas as pd

# Ensure the 'date' column is in datetime format
combined_data['date'] = pd.to_datetime(combined_data['date'])

# Group data by month and year, counting injuries
injury_counts_monthly = combined_data.groupby(combined_data['date'].dt.to_period('M')).size()

# Plot the data
plt.figure(figsize=(14, 7))
plt.bar(injury_counts_monthly.index.astype(str), injury_counts_monthly.values, color='salmon')

# Rotate x-axis labels for better readability
plt.xticks(rotation=45)

# Titles and Labels
plt.title("Monthly Injuries Over Time", fontsize=16)
plt.xlabel("Month", fontsize=12)
plt.ylabel("Injury Count", fontsize=12)
plt.grid(axis='y', linestyle='--', linewidth=0.7)

plt.show()
No description has been provided for this image

Observation: The line plot visualizes the trend of injuries over time, showing how the injury count fluctuates across different dates. It allows for easy identification of periods with a higher or lower incidence of injuries, helping to discern any patterns or trends over the timeline.

Conclusion: By analyzing the injury trend over time, teams and management can identify peak injury periods and assess potential causes, such as intense match schedules, seasonal effects, or other factors. Understanding these trends can inform strategies for injury prevention, such as adjusting training intensity or optimizing player recovery during high-risk periods.

Top 10 Players with Most Injuries¶

In [51]:
player_injury_counts = combined_data['player_id'].value_counts().head(10)

plt.figure(figsize=(12, 6))
sns.barplot(x=player_injury_counts.index, y=player_injury_counts.values, palette='viridis')
plt.title("Top 10 Players with Most Injuries", fontsize=16)
plt.xlabel("Player ID", fontsize=14)
plt.ylabel("Number of Injuries", fontsize=14)
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()
No description has been provided for this image

Observation: The bar chart showcases the top 10 players with the most injuries, with each player’s injury count represented by the height of the corresponding bar. The chart reveals the players most affected by injuries, which could point to specific individuals who may require extra attention in terms of recovery or injury prevention.

Conclusion: Identifying players with the highest injury counts can help teams tailor specific health and fitness strategies to reduce their risk. It may also indicate whether certain players are more prone to injuries due to factors such as playing style, position, or physical condition. Further analysis could focus on identifying common factors among these players to prevent future injuries.

Strategies to Reduce Player Injuries¶

To effectively reduce player injuries, it is crucial to adopt a holistic approach that includes monitoring training loads, ensuring proper warm-up and cool-down routines, and analyzing injury data patterns. Balanced training schedules with adequate rest periods help prevent overtraining, while dynamic stretching and mobility drills before matches, followed by static stretching and foam rolling afterward, reduce muscle stiffness and injury risks. Optimizing substitution strategies based on player fatigue and performance data can also prevent excessive strain. Personalized nutrition and hydration plans, combined with recovery techniques such as cryotherapy and massage therapy, further support injury prevention. Mental well-being should not be overlooked, as stress and fatigue contribute to injury risks. By analyzing injury timing and match events, teams can identify high-risk periods and make tactical adjustments to safeguard players, ensuring better health, improved performance, and fewer injuries.

Injury Distribution by Month¶

In [52]:
combined_data['month'] = combined_data['date'].dt.month
monthly_injury_counts = combined_data['month'].value_counts().sort_index()

plt.figure(figsize=(12, 6))
sns.barplot(x=monthly_injury_counts.index, y=monthly_injury_counts.values, palette='magma')
plt.title("Injury Distribution by Month", fontsize=16)
plt.xlabel("Month", fontsize=14)
plt.ylabel("Number of Injuries", fontsize=14)
plt.tight_layout()
plt.show()
No description has been provided for this image

Observation: The bar chart displays the distribution of injuries by month, with each bar representing the number of injuries recorded for that particular month. The chart reveals fluctuations in injury counts across the months, suggesting certain periods of the year may have higher injury occurrences than others.

Conclusion: The analysis indicates that injury rates may vary seasonally or due to other factors such as match intensity, weather conditions, or player fatigue. Further exploration could identify specific months with unusually high injury rates, allowing teams to focus on prevention strategies during those times. Additionally, examining correlations with match schedules or training loads could provide further insights.

Yellow and Red Cards for Injured Player¶
In [53]:
plt.figure(figsize=(12, 6))
card_counts = combined_data.groupby('player_id').agg(yellow=('yellow_card', 'count'), red=('red_card', 'count')).nlargest(10, 'yellow')
card_counts.plot(kind='bar', stacked=True, color=['yellow', 'red'], figsize=(12, 6))
plt.title('Yellow and Red Cards for Injured Players')
plt.show()

<Figure size 1200x600 with 0 Axes>
No description has been provided for this image
Observation:¶

The pie chart shows the distribution of injuries between home and away matches. The chart reveals the percentage of injuries occurring in each location, with a visual comparison of how the occurrences are divided. The differences in the proportions of injuries between home and away matches suggest there may be a location-based factor influencing injury frequency.

Conclusion:¶

The distribution of injuries between home and away matches could indicate that external factors such as travel, crowd pressure, or environmental conditions might affect injury rates. Further analysis could explore whether this trend holds across different teams, player types, or match conditions to provide deeper insights into how location impacts player injuries.

Home vs. Away Injuries¶

In [54]:
home_away_counts = combined_data['is_home_side'].value_counts()

plt.figure(figsize=(8, 8))
home_away_counts.plot(kind='pie', labels=['Away', 'Home'], autopct='%1.1f%%', startangle=90, colors=['lightblue', 'salmon'])
plt.title("Home vs. Away Injuries", fontsize=16)
plt.ylabel("")  # Hides the y-axis label
plt.tight_layout()
plt.show()
No description has been provided for this image

Player Participation Before and After Injuries¶

In [55]:
participation_before = combined_data[combined_data['is_in_starting_11'] == 1].groupby('player_id').size()
participation_after = combined_data[combined_data['is_in_starting_11'] == 0].groupby('player_id').size()

# Prepare data
impact_data = pd.DataFrame({
    'Matches Before Injuries': participation_before,
    'Matches After Injuries': participation_after
}).fillna(0).head(10)


# Plot
impact_data.plot(kind='bar', figsize=(12, 6), colormap='viridis')
plt.title("Player Participation Before and After Injuries", fontsize=18)
plt.xlabel("Player ID", fontsize=14)
plt.ylabel("Number of Matches", fontsize=14)
plt.xticks(rotation=45, fontsize=12)
plt.yticks(fontsize=12)
plt.legend(fontsize=12)
plt.tight_layout()
plt.show()
No description has been provided for this image
Observation:¶

The bar chart compares player participation in matches before and after injuries, with players who were part of the starting lineup represented. The number of matches played before and after injury varies across players, showing some players with a significant drop in participation after injury, while others maintain or even increase their involvement. This could suggest the varying impact of injuries on player availability.

Conclusion:¶

This analysis highlights the potential effect of injuries on player participation, where some players may struggle to regain their spot in the starting lineup after an injury. Further investigation into recovery times, match conditions, and player roles could help in understanding the factors that contribute to changes in participation post-injury.

"Injury Frequency by Match Location (Home vs. Away)"¶

In [56]:
injury_location_stats = combined_data.groupby(['is_home_side', 'player_id']).size().unstack()

injury_location_stats.T.head(10).plot(kind='bar', stacked=True, figsize=(12, 6), colormap='coolwarm')
plt.title("Injury Frequency by Match Location (Home vs. Away)", fontsize=18)
plt.xlabel("Player ID", fontsize=14)
plt.ylabel("Number of Injuries", fontsize=14)
plt.xticks(rotation=45, fontsize=12)
plt.legend(title="Match Location", labels=["Away", "Home"], fontsize=12)
plt.tight_layout()
plt.show()
No description has been provided for this image
Observation:¶

The bar chart illustrates injury frequency for different players based on whether they played at home or away. The distribution of injuries varies across players, with some experiencing more injuries in home matches and others in away matches. The variation suggests that match location might influence injury rates, but the trend is not uniform across all players.

Conclusion:¶

The analysis provides insights into injury patterns based on match location, which could help in injury prevention strategies. Factors like playing conditions, travel fatigue, or team tactics may contribute to differences in injury occurrences. Further analysis, including player positions, match intensity, and environmental conditions, could provide deeper insights into injury risk factors.

Merging Three datasets¶

In [57]:
def clean_player_id(player_id):
    if isinstance(player_id, str) and player_id.startswith("p"):
        return int(player_id[1:]) 
    return int(player_id)
In [58]:
injuries_df.rename(columns={"athlete_id": "player_id"}, inplace=True)
In [59]:
performance_df['player_id'] = performance_df['player_id'].astype(str).str.extract('(\d+)').astype(int)
player_stats_df['player_id'] = player_stats_df['player_id'].astype(str).str.extract('(\d+)').astype(int)
injuries_df['player_id'] = injuries_df['player_id'].astype(int)
In [60]:
merged_df = pd.merge(performance_df, player_stats_df, on="player_id", how="left")


merged_df = pd.merge(merged_df, injuries_df, on="player_id", how="left")
In [61]:
merged_df["was_injured"] = merged_df["date"].notna()
In [62]:
num_cols = merged_df.select_dtypes(include=["number"]).columns
merged_df[num_cols] = merged_df[num_cols].fillna(merged_df[num_cols].mean())
cat_cols = merged_df.select_dtypes(include=["category", "object"]).columns
merged_df[cat_cols] = merged_df[cat_cols].fillna(merged_df[cat_cols].mode().iloc[0])

merged_df.isnull().sum()
Out[62]:
player_id                   0
goals                       0
assists                     0
pass_accuracy               0
tackles                     0
minutes_played              0
minutes_played_bins         0
match_id                    0
is_in_starting_11           0
substitution_on             0
substitution_off            0
yellow_card                 0
red_card                    0
is_home_side                0
date                   114791
was_injured                 0
dtype: int64
In [63]:
merged_df
Out[63]:
player_id goals assists pass_accuracy tackles minutes_played minutes_played_bins match_id is_in_starting_11 substitution_on substitution_off yellow_card red_card is_home_side date was_injured
0 1 0 2 82.32 3 23 20-30 9630.0 1.0 109.0 109.0 0.0 0.0 0.0 2016-05-11 True
1 1 0 2 82.32 3 23 20-30 9630.0 1.0 109.0 109.0 0.0 0.0 0.0 2016-05-16 True
2 1 0 2 82.32 3 23 20-30 9630.0 1.0 109.0 109.0 0.0 0.0 0.0 2016-07-28 True
3 1 0 2 82.32 3 23 20-30 9630.0 1.0 109.0 109.0 0.0 0.0 0.0 2016-11-11 True
4 1 0 2 82.32 3 23 20-30 9630.0 1.0 109.0 109.0 0.0 0.0 0.0 2016-12-16 True
... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ...
116920 999 0 1 77.94 4 69 60-70 7041.0 0.0 109.0 109.0 0.0 0.0 0.0 NaT False
116921 999 0 1 77.94 4 69 60-70 7045.0 0.0 109.0 109.0 0.0 0.0 0.0 NaT False
116922 999 0 1 77.94 4 69 60-70 7064.0 0.0 109.0 109.0 0.0 0.0 1.0 NaT False
116923 999 0 1 77.94 4 69 60-70 7068.0 0.0 109.0 109.0 0.0 0.0 0.0 NaT False
116924 999 0 1 77.94 4 69 60-70 7082.0 0.0 109.0 109.0 0.0 0.0 1.0 NaT False

116925 rows × 16 columns

In [64]:
merged_df[["goals", "assists", "pass_accuracy", "tackles", "minutes_played"]].describe()
Out[64]:
goals assists pass_accuracy tackles minutes_played
count 116925.000000 116925.000000 116925.000000 116925.000000 116925.000000
mean 1.980800 2.015583 80.325407 4.575702 54.343562
std 1.441681 1.387410 11.501540 2.893251 20.546073
min 0.000000 0.000000 60.000000 0.000000 20.000000
25% 1.000000 1.000000 70.570000 2.000000 37.000000
50% 2.000000 2.000000 80.770000 5.000000 53.000000
75% 3.000000 3.000000 90.460000 7.000000 73.000000
max 4.000000 4.000000 100.000000 9.000000 89.000000
In [65]:
performance_df.describe()
Out[65]:
player_id goals assists pass_accuracy tackles minutes_played
count 4992.000000 4992.000000 4992.000000 4992.000000 4992.000000 4992.000000
mean 65310.116787 2.016627 2.005809 79.997019 4.511218 54.386018
std 99716.090604 1.408793 1.409732 11.500752 2.845285 20.255249
min 1.000000 0.000000 0.000000 60.000000 0.000000 20.000000
25% 4074.750000 1.000000 1.000000 70.047500 2.000000 37.000000
50% 17961.000000 2.000000 2.000000 80.190000 5.000000 54.000000
75% 84919.500000 3.000000 3.000000 89.790000 7.000000 72.000000
max 538207.000000 4.000000 4.000000 100.000000 9.000000 89.000000
In [66]:
import numpy as np
performance_cols = ["goals", "assists", "pass_accuracy", "tackles", "minutes_played"]
merged_df[performance_cols] = merged_df[performance_cols].replace(0, np.nan)

merged_df[performance_cols] = merged_df[performance_cols].fillna(merged_df[performance_cols].mean())
In [67]:
merged_df[performance_cols].describe()
Out[67]:
goals assists pass_accuracy tackles minutes_played
count 116925.000000 116925.000000 116925.000000 116925.000000 116925.000000
mean 2.539640 2.498087 80.325407 5.105631 54.343562
std 0.985638 0.975894 11.501540 2.438459 20.546073
min 1.000000 1.000000 60.000000 1.000000 20.000000
25% 2.000000 2.000000 70.570000 3.000000 37.000000
50% 2.539640 2.498087 80.770000 5.105631 53.000000
75% 3.000000 3.000000 90.460000 7.000000 73.000000
max 4.000000 4.000000 100.000000 9.000000 89.000000
In [68]:
merged_df.head()
Out[68]:
player_id goals assists pass_accuracy tackles minutes_played minutes_played_bins match_id is_in_starting_11 substitution_on substitution_off yellow_card red_card is_home_side date was_injured
0 1 2.53964 2.0 82.32 3.0 23 20-30 9630.0 1.0 109.0 109.0 0.0 0.0 0.0 2016-05-11 True
1 1 2.53964 2.0 82.32 3.0 23 20-30 9630.0 1.0 109.0 109.0 0.0 0.0 0.0 2016-05-16 True
2 1 2.53964 2.0 82.32 3.0 23 20-30 9630.0 1.0 109.0 109.0 0.0 0.0 0.0 2016-07-28 True
3 1 2.53964 2.0 82.32 3.0 23 20-30 9630.0 1.0 109.0 109.0 0.0 0.0 0.0 2016-11-11 True
4 1 2.53964 2.0 82.32 3.0 23 20-30 9630.0 1.0 109.0 109.0 0.0 0.0 0.0 2016-12-16 True

Distribution of Pass Accuracy¶

In [69]:
fig = px.scatter(merged_df, x="pass_accuracy", y=[0] * len(merged_df), 
                 text=merged_df["player_id"],  # Show Player ID
                 title="Player Pass Accuracy Distribution",
                 labels={"pass_accuracy": "Pass Accuracy (%)"},
                 color="pass_accuracy", size_max=10)

fig.update_traces(textposition="top center")
fig.update_layout(yaxis=dict(visible=False))

# Show plot
fig.show()

Observation¶

The histogram shows the distribution of pass accuracy percentages among players. The majority of values seem to cluster around higher percentages, indicating that most players have relatively high pass accuracy. The presence of a KDE (Kernel Density Estimate) curve further helps in visualizing the overall trend, showing whether the distribution is normal, skewed, or has multiple peaks.

Conclusion¶

The data suggests that most players maintain a high level of pass accuracy, which is expected in professional football. A few outliers or lower accuracy percentages might indicate players who attempt riskier passes or play in positions where precision is more challenging. Coaches may use this analysis to identify areas where passing efficiency can be improved or recognize players with exceptional passing abilities.

Top 10 Players with Highest Goals¶

In [70]:
top_players = merged_df.groupby("player_id")["goals"].sum().sort_values(ascending=False).head(10)

plt.figure(figsize=(10,5))
sns.barplot(x=top_players.index, y=top_players.values, palette="viridis")
plt.xlabel("Player ID")
plt.ylabel("Total Goals")
plt.title("Top 10 Players with Highest Goals")
plt.xticks(rotation=45)
plt.show()
No description has been provided for this image

Observation¶

The bar chart highlights the top 10 players who have scored the most goals. The highest goal scorer significantly outperforms others, indicating their crucial role in the team's attacking performance. The distribution shows a slight decline in goals among the top players, suggesting that while a few players dominate goal-scoring, others contribute consistently but at a lower rate.

Conclusion¶

Goal-scoring ability is concentrated among a few key players, making them vital assets for their teams. These players likely have strong finishing skills, receive more goal-scoring opportunities, or play in attacking positions. Teams may need to distribute goal-scoring responsibilities more evenly to reduce reliance on a few individuals and maintain consistent performance throughout a season.

Performance Metrics for Player¶

In [73]:
import dash
import dash_core_components as dcc
import dash_html_components as html
import plotly.graph_objects as go
from dash.dependencies import Input, Output
app = dash.Dash(__name__)
player_ids = merged_df["player_id"].unique()

performance_metrics = ["goals", "assists", "tackles", "pass_accuracy"]
def create_player_chart(player_id):
    values = merged_df[merged_df["player_id"] == player_id][performance_metrics].mean().values
    
    return go.Figure(
        data=[
            go.Bar(
                y=performance_metrics,
                x=values,
                orientation="h",
                marker=dict(color=["blue", "green", "orange", "red"], opacity=0.7),
            )
        ],
        layout=dict(
            title=f"Performance Metrics for Player {player_id}",
            xaxis_title="Performance Value",
            yaxis_title="Metrics",
            xaxis=dict(range=[0, max(values) + 2]),
        ),
    )

app.layout = html.Div([
    html.H1("Player Performance Metrics"),
    dcc.Dropdown(
        id="player-dropdown",
        options=[{"label": f"Player {id}", "value": id} for id in player_ids],
        value=player_ids[0], 
        style={"width": "50%"},
    ),
    dcc.Graph(id="performance-graph"),
])
@app.callback(Output("performance-graph", "figure"), [Input("player-dropdown", "value")])
def update_graph(selected_player_id):
    return create_player_chart(selected_player_id)

if __name__ == "__main__":
    app.run_server(debug=True, port=8051)

Observations¶

The horizontal bar chart illustrates the performance metrics for a single player, highlighting key aspects such as goals, assists, tackles, and pass accuracy. The chart allows for an easy comparison of different attributes, showing which areas the player excels in and which aspects need improvement. The varying bar lengths indicate the player's strengths and weaknesses, with pass accuracy likely having the highest value compared to other metrics.

Conclusion¶

This visualization provides a quick and effective way to analyze an individual player's performance based on key footballing attributes. It helps in understanding the player's playing style and contributions on the field. Coaches and analysts can use such insights to develop training strategies, enhance player strengths, and work on areas requiring improvement.

Top 10 Defenders by Tackles¶

In [74]:
top_tackles = merged_df.groupby('player_id', as_index=False)['tackles'].sum()
top_tackles = top_tackles.nlargest(10, 'tackles')
top_tackles['player_id'] = top_tackles['player_id'].astype(str)

plt.figure(figsize=(12, 6))
ax = sns.barplot(x='tackles', y='player_id', data=top_tackles, palette='Purples_r')

plt.title('Top 10 Defenders by Tackles', fontsize=14, fontweight='bold')
plt.xlabel('Total Tackles', fontsize=12)
plt.ylabel('Player ID', fontsize=12)
plt.xticks(fontsize=10)
plt.yticks(fontsize=10)
for index, value in enumerate(top_tackles['tackles']):
    plt.text(top_tackles['tackles'].iloc[index] + 2, index, f"{value:,}", va='center', fontsize=10, fontweight='bold')

sns.despine()
plt.grid(axis='x', linestyle='--', alpha=0.6)

plt.show()
No description has been provided for this image

Observations¶

The bar chart displays the top 10 defenders based on the number of tackles made. The players at the top of the chart have executed the highest number of tackles, showcasing their strong defensive abilities. The variation in the number of tackles among the top 10 players suggests that some defenders are more aggressive and involved in breaking down opposition plays. The presence of significant gaps between some players indicates a difference in defensive playing styles and involvement in matches.

Conclusion¶

This analysis highlights the most effective defenders in terms of tackles, emphasizing their role in maintaining team stability. Players with the highest number of tackles are crucial in stopping attacks and regaining possession for their teams. Their defensive contributions are vital for success, especially in high-pressure games, demonstrating their importance in tactical setups and overall match performance.

Distribution of Players Based on Total Tackles¶

In [75]:
tackles_per_player = merged_df.groupby('player_id', as_index=False)['tackles'].sum()
bins = list(range(0, 1001, 100)) + [float('inf')]
labels = [f"{i}-{i+100}" for i in range(0, 1000, 100)] + ["1000+"]
tackles_per_player['tackle_range'] = pd.cut(tackles_per_player['tackles'], bins=bins, labels=labels, right=False)
tackle_range_counts = tackles_per_player['tackle_range'].value_counts().sort_index()

plt.figure(figsize=(10, 6))
ax = sns.barplot(x=tackle_range_counts.index, y=tackle_range_counts.values, palette='Purples_r')

for index, value in enumerate(tackle_range_counts.values):
    plt.text(index, value + 0.5, str(value), ha='center', fontsize=10, fontweight='bold')

plt.xlabel("Total Tackles Range", fontsize=12)
plt.ylabel("Number of Players", fontsize=12)
plt.title("Distribution of Players Based on Total Tackles (100-Tackle Intervals)", fontsize=14, fontweight='bold')
plt.grid(axis='y', linestyle='--', alpha=0.6)

plt.show()
No description has been provided for this image

Top 10 Players with Most Minutes Played¶

In [76]:
def format_minutes(minutes):
    hours = minutes // 60
    mins = minutes % 60
    return f"{hours}h {mins}m"
top_minutes = merged_df.groupby('player_id', as_index=False)['minutes_played'].sum()
top_minutes = top_minutes.nlargest(10, 'minutes_played')

top_minutes['player_id'] = top_minutes['player_id'].astype(str)

top_minutes['formatted_time'] = top_minutes['minutes_played'].apply(format_minutes)

plt.figure(figsize=(12, 6))
ax = sns.barplot(x='minutes_played', y='player_id', data=top_minutes, palette='coolwarm')

plt.title('Top 10 Players with Most Minutes Played (Football Match Format)', fontsize=14, fontweight='bold')
plt.xlabel('Total Minutes Played', fontsize=12)
plt.ylabel('Player ID', fontsize=12)
plt.xticks(fontsize=10)
plt.yticks(fontsize=10)
for index, value in enumerate(top_minutes['formatted_time']):
    plt.text(top_minutes['minutes_played'].iloc[index] + 5, index, value, va='center', fontsize=10, fontweight='bold')
sns.despine()
plt.grid(axis='x', linestyle='--', alpha=0.6)

plt.show()
No description has been provided for this image

Observations¶

The bar chart presents the top 10 players who have played the most minutes in football matches. The minutes are displayed in a football match format (hours and minutes) for better clarity. Players at the top of the chart have significantly higher playing time, indicating their importance to their teams. The distribution of playing time shows that some players have accumulated much more time on the field than others, reflecting their consistency and durability.

Conclusion¶

The analysis highlights the players who have consistently contributed the most time on the field, suggesting they are key players for their teams. Their high playing minutes indicate their fitness levels, reliability, and importance in match strategies. Such players are often crucial for maintaining team performance and are likely to have a significant impact on the outcomes of matches.

Distribution of Players Based on Minutes Played (1000-Minute Intervals¶

In [77]:
def format_minutes(minutes):
    hours = minutes // 60
    mins = minutes % 60
    return f"{hours}h {mins}m"
players_minutes = merged_df.groupby('player_id', as_index=False)['minutes_played'].sum()
bins = list(range(0, 10000, 1000))
labels = [f"{i}-{i+1000}" for i in range(0, 9000, 1000)] + ["9000+"]
players_minutes['minutes_range'] = pd.cut(players_minutes['minutes_played'], 
                                          bins=bins + [float('inf')], labels=labels, right=False)

minutes_range_counts = players_minutes['minutes_range'].value_counts().sort_index()

plt.figure(figsize=(10, 6))
ax = sns.barplot(x=minutes_range_counts.index, y=minutes_range_counts.values, palette='coolwarm')

for index, value in enumerate(minutes_range_counts.values):
    plt.text(index, value + 1, str(value), ha='center', fontsize=10, fontweight='bold')

plt.xlabel("Total Minutes Played Range", fontsize=12)
plt.ylabel("Number of Players", fontsize=12)
plt.title("Distribution of Players Based on Minutes Played (1000-Minute Intervals)", fontsize=14, fontweight='bold')


plt.grid(axis='y', linestyle='--', alpha=0.6)
plt.xticks(rotation=45)  
sns.despine()

plt.show()
No description has been provided for this image
In [ ]:

Percentage of Matches Where Players Played Full 90 Minutes¶

In [78]:
bins = list(range(0, 91, 15))
labels = [f"{i}-{i+15} min" for i in range(0, 90, 15)]
time_intervals = pd.cut(merged_df['minutes_played'], bins=bins, labels=labels, right=False)
time_counts = time_intervals.value_counts().sort_index()

plt.figure(figsize=(8, 8))
colors = sns.color_palette("coolwarm", len(time_counts))
plt.pie(time_counts, labels=time_counts.index, autopct='%1.1f%%', colors=colors, startangle=140)
plt.title("Distribution of Players Based on Time Played Per Match (15-Minute Intervals)")
plt.show()
No description has been provided for this image

Observations¶

The pie chart presents the proportion of matches where players played the full 90 minutes versus those where they played less than 90 minutes. The green section represents the percentage of matches where players completed the entire game, while the red section shows matches where they were either substituted or did not play the full duration. A significantly larger red portion suggests that most players do not complete the full 90 minutes regularly, indicating frequent substitutions, injuries, or tactical rotations.

Conclusion¶

The analysis highlights that a small percentage of players consistently play full matches, which aligns with modern football strategies that emphasize squad rotation, injury prevention, and tactical substitutions. Coaches often make changes to maintain energy levels, adapt to match situations, and manage player workloads across a long season.

Top 10 Players Who Rarely Miss Matches¶

In [79]:
players_played_all_matches = merged_df.groupby('player_id', as_index=False)['is_in_starting_11'].sum()
players_played_all_matches = players_played_all_matches.nlargest(10, 'is_in_starting_11')

players_played_all_matches['player_id'] = players_played_all_matches['player_id'].astype(str)
plt.figure(figsize=(12, 6))
ax = sns.barplot(x='is_in_starting_11', y='player_id', data=players_played_all_matches, palette='coolwarm')
plt.title('Top 10 Players Who Rarely Miss Matches', fontsize=14, fontweight='bold')
plt.xlabel('Total Matches Started', fontsize=12)
plt.ylabel('Player ID', fontsize=12)
plt.xticks(fontsize=10)
plt.yticks(fontsize=10)
for index, value in enumerate(players_played_all_matches['is_in_starting_11']):
    plt.text(players_played_all_matches['is_in_starting_11'].iloc[index] + 0.5, index, f"{value}", va='center', fontsize=10, fontweight='bold')

sns.despine()
plt.grid(axis='x', linestyle='--', alpha=0.6)

plt.show()
No description has been provided for this image

Distribution of Players Based on Matches Started (100-Game Intervals)¶

In [80]:
players_played_all_matches = merged_df.groupby('player_id', as_index=False)['is_in_starting_11'].sum()
bins = list(range(0, 1000, 100)) 
labels = [f"{i}-{i+100}" for i in range(0, 900, 100)] + ["900+"]
players_played_all_matches['matches_range'] = pd.cut(players_played_all_matches['is_in_starting_11'], 
                                                     bins=bins + [float('inf')], labels=labels, right=False)

matches_range_counts = players_played_all_matches['matches_range'].value_counts().sort_index()
plt.figure(figsize=(10, 6))
ax = sns.barplot(x=matches_range_counts.index, y=matches_range_counts.values, palette='coolwarm')

for index, value in enumerate(matches_range_counts.values):
    plt.text(index, value + 1, str(value), ha='center', fontsize=10, fontweight='bold')

plt.xlabel("Total Matches Started Range", fontsize=12)
plt.ylabel("Number of Players", fontsize=12)
plt.title("Distribution of Players Based on Matches Started (100-Game Intervals)", fontsize=14, fontweight='bold')

plt.grid(axis='y', linestyle='--', alpha=0.6)
plt.xticks(rotation=45)  
sns.despine()

plt.show()
No description has been provided for this image

Observations¶

The plot highlights the top 10 players who have started the most matches, emphasizing their reliability and importance to the team. Players at the top have consistently been in the starting XI, indicating their key role and fitness levels. There is some variation among the top 10, suggesting that some players missed matches due to rotation, tactical decisions, or injuries. The slight drop-off in values from the highest to the lowest within the top 10 further supports this.

Conclusion¶

From this, we can conclude that these players form the core of the team, as they are regularly selected to start. Their high match appearances suggest strong fitness, consistency, and trust from the coaching staff. These players are likely crucial in determining the team’s overall performance throughout the season.

Filtering Players Present in All Datasets¶

In [81]:
common_player_ids = set(performance_df['player_id']) & set(player_stats_df['player_id']) & set(injuries_df['player_id'])

matched_df = merged_df[merged_df['player_id'].isin(common_player_ids)]
matched_df
Out[81]:
player_id goals assists pass_accuracy tackles minutes_played minutes_played_bins match_id is_in_starting_11 substitution_on substitution_off yellow_card red_card is_home_side date was_injured
0 1 2.53964 2.0 82.32 3.0 23 20-30 9630.0 1.0 109.0 109.0 0.0 0.0 0.0 2016-05-11 True
1 1 2.53964 2.0 82.32 3.0 23 20-30 9630.0 1.0 109.0 109.0 0.0 0.0 0.0 2016-05-16 True
2 1 2.53964 2.0 82.32 3.0 23 20-30 9630.0 1.0 109.0 109.0 0.0 0.0 0.0 2016-07-28 True
3 1 2.53964 2.0 82.32 3.0 23 20-30 9630.0 1.0 109.0 109.0 0.0 0.0 0.0 2016-11-11 True
4 1 2.53964 2.0 82.32 3.0 23 20-30 9630.0 1.0 109.0 109.0 0.0 0.0 0.0 2016-12-16 True
... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ...
116688 9 4.00000 3.0 68.04 6.0 58 50-60 5833.0 0.0 91.0 109.0 0.0 0.0 1.0 2016-09-14 True
116689 9 4.00000 3.0 68.04 6.0 58 50-60 5842.0 0.0 67.0 109.0 0.0 0.0 0.0 2016-09-14 True
116690 9 4.00000 3.0 68.04 6.0 58 50-60 5852.0 1.0 109.0 109.0 0.0 0.0 1.0 2016-09-14 True
116691 9 4.00000 3.0 68.04 6.0 58 50-60 5858.0 1.0 109.0 19.0 0.0 0.0 0.0 2016-09-14 True
116692 9 4.00000 3.0 68.04 6.0 58 50-60 5885.0 0.0 109.0 109.0 0.0 0.0 0.0 2016-09-14 True

2134 rows × 16 columns

Observation:
The matched_df dataset contains only those player_ids that are present in all three datasets—performance_df, player_stats_df, and injuries_df. Players who are missing from at least one dataset have been excluded, ensuring that the analysis is based on complete and reliable data. As a result, the number of players in matched_df is lower than in merged_df, since some players exist in only one or two datasets but not all three. This filtering process helps in reducing missing values (NaN) and enhances the accuracy of comparisons across performance metrics, player statistics, and injury records.

In [82]:
print(f"Total players found in all datasets: {matched_df.shape[0]}")

Total players found in all datasets: 2134
In [83]:
matched_df.columns
Out[83]:
Index(['player_id', 'goals', 'assists', 'pass_accuracy', 'tackles',
       'minutes_played', 'minutes_played_bins', 'match_id',
       'is_in_starting_11', 'substitution_on', 'substitution_off',
       'yellow_card', 'red_card', 'is_home_side', 'date', 'was_injured'],
      dtype='object')

Trend of Injuries Over Time¶

In [84]:
matched_df['date'] = pd.to_datetime(matched_df['date'])
matched_df['year_month'] = matched_df['date'].dt.to_period('M')
injury_trend = matched_df.groupby(matched_df['year_month'])['was_injured'].sum()
injury_trend.index = injury_trend.index.to_timestamp()
plt.figure(figsize=(12, 6))
sns.lineplot(x=injury_trend.index, y=injury_trend.values, marker='o', color='red')

plt.xlabel("Month", fontsize=12)
plt.ylabel("Number of Injuries", fontsize=12)
plt.title("Monthly Injury Trend Over Time", fontsize=14, fontweight='bold')
plt.xticks(rotation=45)  # Rotate x-axis labels for better readability
plt.grid(True, linestyle='--', alpha=0.6)

plt.show()
No description has been provided for this image

Observation:¶

The line plot shows yearly variations in the number of injuries. There might be certain years where injuries peaked, possibly due to increased match intensity, schedule congestion, or other factors like changes in training methods. Conversely, some years may have fewer injuries, indicating better recovery protocols or improved player fitness management.

Conclusion:¶

The trend highlights key periods of high injury occurrences, which can be useful for teams and medical staff to analyze risk factors, workload, and injury prevention strategies. If injuries have been increasing, it may suggest a need for better rotation policies, recovery plans, or training adjustments to reduce injury risk in future seasons.

Top 5 Players with Most Injuries**¶

In [85]:
injury_counts = matched_df.groupby('player_id')['was_injured'].sum().nlargest(5).reset_index()
plt.figure(figsize=(8, 5))
ax = sns.barplot(y=injury_counts['player_id'].astype(str), x=injury_counts['was_injured'], palette='Reds_r')
for index, value in enumerate(injury_counts['was_injured']):
    ax.text(value + 0.2, index, str(value), va='center', fontsize=10, fontweight='bold')
plt.xlabel("Number of Injuries", fontsize=12)
plt.ylabel("Player ID", fontsize=12)
plt.title("Top 5 Players with Most Injuries", fontsize=14, fontweight='bold')
plt.grid(axis='x', linestyle='--', alpha=0.6)
plt.show()
No description has been provided for this image

Observation:¶

The bar chart clearly shows that some players have significantly more injuries than others. The top injured player has the highest count, while the other four players also have a considerable number of injuries. This suggests that certain players may be more prone to injuries due to factors like playing position, aggressive playstyle, or lack of proper recovery.

Conclusion:¶

By identifying the most injury-prone players, teams can focus on better injury prevention strategies, including personalized training, workload management, and improved medical support. If specific players consistently appear on this list, it may indicate the need for tailored fitness programs or rotation strategies to minimize injury risks.

Top 5 Players Based on Performance Score**¶

In [86]:
from sklearn.preprocessing import MinMaxScaler
performance_metrics = ['goals', 'assists', 'pass_accuracy', 'tackles']
scaler = MinMaxScaler()
matched_df[performance_metrics] = scaler.fit_transform(matched_df[performance_metrics])
matched_df['performance_score'] = matched_df[performance_metrics].sum(axis=1)
top_players = matched_df.groupby('player_id')['performance_score'].mean().nlargest(10).reset_index()

plt.figure(figsize=(10, 6))
ax = sns.barplot(y=top_players['player_id'].astype(str), x=top_players['performance_score'], palette='viridis')

for index, value in enumerate(top_players['performance_score']):
    ax.text(value + 0.02, index, f"{value:.2f}", va='center', fontsize=10, fontweight='bold')
    
plt.xlabel("Performance Score", fontsize=12)
plt.ylabel("Player ID", fontsize=12)
plt.title("Top 5 Players Based on Performance Score", fontsize=14, fontweight='bold')
plt.grid(axis='x', linestyle='--', alpha=0.6)
plt.show()
No description has been provided for this image

Observation:¶

The top-performing players have significantly higher scores, indicating their well-rounded contributions. Players with more goals, assists, accurate passing, and defensive efforts rank higher. The distribution suggests that some players excel in all areas, while others might be specialists in one or two metrics.

Conclusion:¶

This multi-metric analysis helps in identifying consistent and versatile players. Coaches and analysts can use this to make better squad selection decisions, assess player efficiency, and fine-tune team strategies. If certain players are consistently ranking high, they might be key playmakers or leaders on the field.

Improving Player Performance & Reducing Injuries¶

In [87]:
matched_df['date'] = pd.to_datetime(matched_df['date'])
injury_trend = matched_df.groupby(matched_df['date'].dt.month)['was_injured'].sum()

plt.figure(figsize=(10, 5))
sns.lineplot(x=injury_trend.index, y=injury_trend.values, marker='o', color='red')

plt.xlabel("Month", fontsize=12)
plt.ylabel("Number of Injuries", fontsize=12)
plt.title("Injury Trend Over the Months", fontsize=14, fontweight="bold")
plt.grid(axis="y", linestyle="--", alpha=0.6)

plt.show()
No description has been provided for this image

Observation¶

High-injury months = reduce training intensity & improve recovery plans.

In [88]:
injury_counts = matched_df.groupby("player_id")["was_injured"].sum().sort_values(ascending=False).head(10)

plt.figure(figsize=(10, 5))
sns.barplot(x=injury_counts.index, y=injury_counts.values, palette="Reds")

plt.xlabel("Player ID", fontsize=12)
plt.ylabel("Total Injuries", fontsize=12)
plt.title("Players with Most Injuries", fontsize=14, fontweight="bold")
plt.xticks(rotation=45)
plt.show()
No description has been provided for this image

Observation¶

Players with the most injuries need hydration monitoring & stretching exercises

Performance Improvement and Injury Reduction On Basis Of above analysis¶

1. Performance Improvement Strategies¶

To enhance player performance, we analyzed key metrics such as goals, assists, pass accuracy, and tackles. The insights from our dataset suggest the following improvements:

  • Players with consistently high performance scores should receive more playtime in crucial matches.
  • Rotation of underperforming players can improve overall team efficiency.
  • Midfielders should focus on improving passing accuracy and assists.
  • Forwards should undergo specialized training to enhance goal-scoring efficiency.
  • Defenders need to improve tackling skills while maintaining discipline to avoid unnecessary fouls.

2. Injury Reduction Strategies¶

  • Our injury trend analysis shows spikes in specific months, indicating the need for workload adjustments.
  • Strength and conditioning training should be intensified in pre-season while reducing high-intensity training in peak injury periods.
  • Players who participate in excessive consecutive matches have a higher injury risk.
  • A well-planned rotation strategy can help prevent overuse injuries.
  • Our analysis shows that defenders contribute to a significant number of injuries due to aggressive tackles.
In [ ]:
In [ ]:
In [ ]: